package com.xmut.mall.search.service.impl;

import cn.easyes.core.biz.PageInfo;
import cn.easyes.core.conditions.LambdaEsQueryWrapper;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import com.xmut.mall.search.es.document.product.Attrs;
import com.xmut.mall.search.es.document.product.ProductESPojo;
import com.xmut.mall.search.es.mapper.ProductEsMapper;
import com.xmut.mall.search.feign.CouponFeignClient;
import com.xmut.mall.search.feign.ProductFeignClient;
import com.xmut.mall.search.feign.WareFeignClient;
import com.xmut.mall.search.searchparam.ProductSearchParam;
import com.xmut.mall.search.service.ProductService;
import com.xmut.mall.search.to.AttrEntityTo;
import com.xmut.mall.search.to.BrandEntityTo;
import com.xmut.mall.search.utils.RespBean;
import com.xmut.mall.search.vo.*;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.apache.bcel.generic.ClassGen;
import org.elasticsearch.action.search.SearchResponse;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Slf4j
@Service
public class ProductServiceImpl implements ProductService {

    @Autowired
    private ProductEsMapper productEsMapper;

    @Autowired
    private ProductFeignClient productFeignClient;

    @Autowired
    private CouponFeignClient couponFeignClient;

    @Autowired
    private WareFeignClient wareFeignClient;

    @Override
    public boolean productUp(List<ProductESPojo> skuEsModels) {
        System.out.println("skuEsModel:" + skuEsModels);
        // 使用Easy es 进行上架
        Integer integer = productEsMapper.insertBatch(skuEsModels);
        System.out.println("上架条数:" + integer);
        if (integer > 0) {
            log.info("ES上架成功{}条", integer);
            return true;
        } else {
            log.error("ES上架失败");
            return false;
        }
    }

    /**
     * 根据分类Id获取商品
     *
     * @param cateId
     * @return
     */
    @Override
    public List<ProductESPojo> getProductByCateId(Long cateId) {
        List<ProductESPojo> products =
                productEsMapper.selectList(new LambdaEsQueryWrapper<ProductESPojo>().eq("catalogId", cateId));
        return products;
    }

    /**
     * 根据搜索框输入的KeyWord获取商品的可检索attr属性
     *
     * @param keyword
     * @return
     */
    @Override
    public List<AttrEntityTo> getProductAttrByKeyWord(String keyword) {
        // 全文检索该keyword
        List<ProductESPojo> products = productEsMapper.selectList(new LambdaEsQueryWrapper<ProductESPojo>().eq("skuTitle", keyword));

        if (products.isEmpty()) {
            // 如果全文检索的结果是null就不查了直接返回null
            return null;
        } else {
            // 如果不为空在feign调用去查询
            // 获取cateId
            Long catalogId = products.get(0).getCatalogId();

            // 发送feign请求
            RespBean respBean = productFeignClient.getAbleToSearchAttrByCateId(catalogId);

            return JSON.parseObject(JSON.toJSONString(respBean.getObj()), new TypeReference<List<AttrEntityTo>>() {
            });
        }

    }

    /**
     * 根据输入框输入的KeyWord获取商品列表
     *
     * @param keyword
     * @return
     */
    @Override
    public List<ProductESPojo> getProductByKeyWord(String keyword) {
        // 根据KeyWord进行匹配将匹配结果返回
        return productEsMapper.selectList(new LambdaEsQueryWrapper<ProductESPojo>().eq("skuTitle", keyword));
    }

    /**
     * 使用keyword获取可进行检索的品牌信息
     *
     * @param keyword
     * @return
     */
    @Override
    public List<BrandEntityTo> getProductBrandByKeyWord(String keyword) {
        // 根据skutitle进行全文检索
        List<ProductESPojo> products = productEsMapper.selectList(new LambdaEsQueryWrapper<ProductESPojo>().eq("skuTitle", keyword));

        if (products.isEmpty()) {
            // 如果全文检索匹配的结果是null就直接返回null
            return null;
        } else {
            // 如果全文检索的结果不为null操作继续
            // 随机拿到第一个商品(最符合keyword得分最高的最匹配的)获取cateid
            Long catalogId = products.get(0).getCatalogId();
            // 获取可检索的品牌
            RespBean respBean = productFeignClient.getBrandByCateId(catalogId);

            return JSON.parseObject(JSON.toJSONString(respBean.getObj()), new TypeReference<List<BrandEntityTo>>() {
            });
        }
    }

    /**
     * 根据skuId获取商品的所属品牌
     *
     * @param skuId
     * @return
     */
    @Override
    public String getProductBrandNameBySkuId(Long skuId) {
        ProductESPojo productESPojo = productEsMapper.selectById(skuId);
        return productESPojo.getBrandName();
    }

    /**
     * 根据skuId获取商品信息
     *
     * @param skuId
     * @return
     */
    @Override
    public ProductESPojo getProductBySkuId(Long skuId) {
        return productEsMapper.selectById(skuId);
    }

    /**
     * 根据skuId获取商品详细信息
     *
     * @param skuId
     * @return
     */
//    @Cacheable(value = "ProductDetail", key = "#root.methodName+#root.args[0]")
    @Override
    public ProductVo getProductDetailVoBySkuId(Long skuId) {
        // 我们之后要返回的数据
        ProductVo productVo = new ProductVo();
        // 先查es中的数据
        ProductESPojo productESPojo = productEsMapper.selectById(skuId);
        // 往Vo set productESPojo的属性
        BeanUtils.copyProperties(productESPojo, productVo);

        Map<String,Object> promotionMap = new HashMap<>();

        // 向product发送feign请求获取商品展示图片集合(包详细介绍和展示图)
        RespBean respBean = productFeignClient.getSkuImageBySkuId(skuId);
        if (respBean.getCode() == 201) {
            // 请求成功
            // 转化收到的数据
            List<SkuImagesEntity> skuImages = JSON.parseObject(JSON.toJSONString(respBean.getObj()), new TypeReference<List<SkuImagesEntity>>() {
            });
            // set进vo
            productVo.setImages(skuImages);
        }

        RespBean skuDescResp = productFeignClient.getSkuDescById(skuId);
        if (skuDescResp.getCode() == 201){
            SkuDescVo skuDescVo = JSON.parseObject(JSON.toJSONString(skuDescResp.getObj()), SkuDescVo.class);
            // 拼接String 因为前端需要带标签返回
            StringBuffer stringBuffer = new StringBuffer();
            stringBuffer.append("<p> <img src=\"");
            stringBuffer.append(skuDescVo.getSkuDesc() + "\"");
//            stringBuffer.append("“");
            stringBuffer.append(" style=\"max-width:100%;" + "\"");
//            stringBuffer.append("“");
            stringBuffer.append("><br/></p>");

            productVo.setDetailImage(stringBuffer.toString());
        }


        // TODO: 2022/10/20 先给个0现在那边还没做
        productVo.setCommentNum(0L);

//        RespBean skuSaleAttrValueBySpuId = productFeignClient.getSkuSaleAttrValueBySpuId(productESPojo.getSpuId());
//        if(skuSaleAttrValueBySpuId.getCode() == 201){
//            // 请求成功 转换类型
//            List<SkuSaleAttrValueVo> skuSaleAttrValueVos = JSON.parseObject(JSON.toJSONString(skuSaleAttrValueBySpuId.getObj()), new TypeReference<List<SkuSaleAttrValueVo>>() {
//            });
//            // 向vo set数据
//            productVo.setFormatList(skuSaleAttrValueVos);
//        }

        // 获取库存信息
        RespBean wareNumberResp = wareFeignClient.getSkuWareNumber(skuId);
        if (wareNumberResp.getCode() == 201){
            Integer wareNum = JSON.parseObject(JSON.toJSONString(wareNumberResp.getObj()), Integer.class);
            // 设置库存
            productVo.setQuantity(wareNum);
        }

        // 设置重量
        RespBean spuInfoBySpuId = productFeignClient.getSpuInfoBySpuId(productESPojo.getSpuId());
        if (spuInfoBySpuId.getCode() == 201) {
            // 请求成功 进行类型转换
            SpuInfoVo spuInfoVo = JSON.parseObject(JSON.toJSONString(spuInfoBySpuId.getObj()), SpuInfoVo.class);
            // 设置重量
            productVo.setWeight(spuInfoVo.getWeight());
            productVo.setSpuName(spuInfoVo.getSpuName());
        }

        // 远程请求优惠券信息
        RespBean productDetailCouponResp = couponFeignClient.getProductDetailCoupon(skuId, productESPojo.getCatalogId());
        if (productDetailCouponResp.getCode()==201){
            List<CouponEntityVo> couponEntityVos = JSON.parseObject(JSON.toJSONString(productDetailCouponResp.getObj()), new TypeReference<List<CouponEntityVo>>() {
            });
            productVo.setCoupons(couponEntityVos);
            promotionMap.put("COUPON",productDetailCouponResp.getObj());
        }

        //远程请求满减信息
        RespBean productDetailFullDiscountResp = couponFeignClient.getProductDetailFullDiscount(skuId);
        if (productDetailFullDiscountResp.getCode() == 201){
            List<FullDiscountEntityVo> fullDiscountEntityVos = JSON.parseObject(JSON.toJSONString(productDetailFullDiscountResp.getObj()), new TypeReference<List<FullDiscountEntityVo>>() {
            });
            productVo.setFullReduce(fullDiscountEntityVos);
            promotionMap.put("FULL_DISCOUNT",productDetailFullDiscountResp.getObj());
        }

        // 远程请求sku销售属性分组
        RespBean skuSaleAttrValueByCateId = productFeignClient.getSkuSaleAttrValueByCateId(productESPojo.getCatalogId(), skuId, productESPojo.getSpuId());
        if (skuSaleAttrValueByCateId.getCode() == 201) {
            // 请求成功 进行数据解析
            List<SaleAttrVo> saleAttrVos = JSON.parseObject(JSON.toJSONString(skuSaleAttrValueByCateId.getObj()), new TypeReference<List<SaleAttrVo>>() {
            });
            productVo.setSaleAttr(saleAttrVos);
        }

        // 远程请求商品详情中用来展示的销售属性
        RespBean productAttrValueBySpuId = productFeignClient.getProductAttrValueBySpuId(productESPojo.getSpuId());
        if (productAttrValueBySpuId.getCode() == 201) {
            // 请求成功 解析响应体
            List<ProductAttrValueVo> productAttrValueVos = JSON.parseObject(JSON.toJSONString(productAttrValueBySpuId.getObj()), new TypeReference<List<ProductAttrValueVo>>() {
            });
            productVo.setShowAttr(productAttrValueVos);
        }
        productVo.setPromotionMap(promotionMap);
        return productVo;
    }

    /**
     * 获取所有商品
     *
     * @return
     */
    @Override
    public List<ProductESPojo> getAllProduct() {
        List<ProductESPojo> productESPojoList = productEsMapper.selectList(new LambdaEsQueryWrapper<ProductESPojo>());
        return productESPojoList;
    }

    /**
     * 快捷重置文档接口
     *
     * @return
     */
    @Override
    public RespBean deleteDocument() {
        List<ProductESPojo> productESPojoList = productEsMapper.selectList(new LambdaEsQueryWrapper<ProductESPojo>());
        List<Long> skuIds = productESPojoList.stream().map(ProductESPojo::getSkuId).collect(Collectors.toList());
        Integer integer = productEsMapper.deleteBatchIds(skuIds);

        return RespBean.success("删除了:" + integer + "条");

    }

    /**
     * 商品下架
     *
     * @param skuIds
     * @return
     */
    @Override
    public boolean productOFF(List<Long> skuIds) {
        Integer integer = productEsMapper.deleteBatchIds(skuIds);

        if (integer > 0) {
            return true;
        } else {
            return false;
        }

    }

    /**
     * 根据搜索的keyword获取商品的分页参数
     *
     * @param param
     * @return
     */
    @Override
    public RespBean getProductPageByKeyWord(ProductSearchParam param) {

        PageInfo<ProductESPojo> skuTitle = productEsMapper.pageQuery(new LambdaEsQueryWrapper<ProductESPojo>()
                .eq("skuTitle", param.getKeyword()), param.getPageNumber(), param.getPageSize());

        return RespBean.success("获取成功", skuTitle);

    }

    /**
     * 根据cateId搜索ES商品
     *
     * @param param
     * @return
     */
    @Override
    public RespBean getProductPageByCateId(ProductSearchParam param) {

        PageInfo<ProductESPojo> catalogId = productEsMapper.pageQuery(new LambdaEsQueryWrapper<ProductESPojo>()
                .eq("catalogId", param.getCategoryId()), param.getPageNumber(), param.getPageSize());

        return RespBean.success("获取成功",catalogId);

    }
}
